#include "Sql_list.h"

/** 初始化
 * 函数名 Init_Sql_List
 * 参数
 *      @L 需要初始化的 静态表
 * 返回值
 *      无
 * 功能
 *      对静态表进行初始化
 */
void Init_Sql_List(Sql_list *L)
{
    // 对创建的数据做清空
    memset(L->data, 0, 50 * sizeof(L->data[0]));
    // 初始化表的长度 len
    L->len = 0;
}

/** 尾插
 * 函数名 tail_insert_list
 * 参数
 *      @L 需要尾插的 静态表
 *      @data 需要插入的数据
 * 返回值
 *      无
 * 功能
 *      对静态表进行尾插
 */
void tail_insert_list(Sql_list *L, Elenemt_data data)
{
    // 安全判断
    if (NULL == L)
    {
        printf("顺序表 为 NULL \n");
        return;
    }
    if (MAX_SIZ <= L->len)
    {
        printf("顺序表 为 满 \n");
        return;
    }

    // 插入
    L->data[L->len] = data;
    // 迭代
    L->len++;
}

/** 尾删
 * 函数名 tail_del_list
 * 参数
 *      @L 需要尾删的 静态表
 * 返回值
 *      无
 * 功能
 *      对静态表进行尾删
 */
void tail_del_list(Sql_list *L)
{
    // 安排判断
    if (NULL == L)
    {
        printf("顺序表 为 NULL \n");
        return;
    }
    if (0 >= L->len)
    {
        printf("顺序表 内 无数据 \n");
        return;
    }

    // memset(&L->data[L->len] , sizeof(L->data[0]) , 0);

    L->len--;
}

/** 遍历打印
 * 函数名 printf_Sql_List
 * 参数
 *      @L 需要遍历的 静态表
 * 返回值
 *      无
 * 功能
 *      对静态表进行尾插
 */
void printf_Sql_List(Sql_list *L)
{
    // 安全判断
    if (NULL == L)
    {
        printf("顺序表 为 NULL \n");
        return;
    }
    if (0 == L->len)
    {
        printf("顺序表 内 无数据 \n");
        return;
    }

    for (size_t i = 0; i < L->len; i++)
    {
        printf("姓名:%s 性别:%s 年龄:%d 成绩:%d 学号:%d\n",
               L->data[i].name, L->data[i].sex, L->data[i].age,
               L->data[i].sco, L->data[i].id);
    }
}

/** 判空
 * 函数名 IsEmpty_Sql_List
 * 参数
 *      @L 需要判空的 静态表
 * 返回值
 *      0 代表 为 空
 *      1 代表 不为 空
 * 功能
 *    判断表是否为空
 *
 */
int IsEmpty_Sql_List(Sql_list *L)
{
    // 安全判断
    if (NULL == L)
    {
        printf("顺序表 为 NULL \n");
        return 0;
    }

    if (0 >= L->len)
    {
        printf("IsEmpty_Sql_List : 表为空\n");
        return 0;
    }
    printf("IsEmpty_Sql_List : 表不为空\n");
    return 1;
}

/** 清空
 * 函数名 Clear_Sql_List
 * 参数
 *      @L 需要清空的 静态表
 * 返回值
 *      无
 * 功能
 *      清空顺序表
 */
void Clear_Sql_List(Sql_list *L)
{
    // 安全判断
    if (NULL == L)
    {
        printf("顺序表 为 NULL \n");
        return;
    }
    memset(L->data, 0, MAX_SIZ * sizeof(L->data[0]));
    L->len = 0;
}

/** 任意位置插入
 * 函数名 pos_insert_list
 * 参数
 *      @L 需要插入的 静态表
 *      @index 需要插入的位置
 *      @data 插入的数据
 * 返回值
 *      无
 * 功能
 *      任意位置插入
 */
void pos_insert_list(Sql_list *L, int pos, Elenemt_data data)
{
    // 安全判断
    if (NULL == L)
    {
        printf("顺序表 为 NULL \n");
        return;
    }
    if (MAX_SIZ <= L->len)
    {
        printf("顺序表 为 满 \n");
        return;
    }
    if (L->len + 1 < pos)
    {
        printf("index 参数不合法 \n");
        return;
    }

    // =================== 开始插入 ===================
    if (pos == L->len + 1) // 尾插入
    {
        // 插入
        L->data[L->len] = data;
        // 迭代
        L->len++;
        return;
    }
    // 中间插入

    for (size_t i = L->len; i >= pos; i--)
    {
        L->data[i] = L->data[i - 1];
    }
    /*
    条件 i = L->len  = 3
        pos = 1
    10 20 30
    第一次循环  i >= pos  条件满足  3 >= 1
        做一次交换   i--
    10 20 30 30
    第二次循环  i >= pos  条件满足  2 >= 1
        做二次交换   i--
    10 20 20 30
    第三次循环  i >= pos  条件满足  1 >= 1
        做三次交换   i--
    10 10 30 30
    */

    L->data[pos - 1] = data;
    L->len++;
    return;
}

/** 任意位置删除
 * 函数名 pos_insert_list
 * 参数
 *      @L 需要插入的 静态表
 *      @index 需要删除的位置
 * 返回值
 *      无
 * 功能
 *      任意位置删除
 */
void pos_del_list(Sql_list *L, int pos)
{
    // 安排判断
    if (NULL == L)
    {
        printf("顺序表 为 NULL \n");
        return;
    }
    if (0 >= L->len)
    {
        printf("顺序表 内 无数据 \n");
        return;
    }
    if (pos > L->len)
    {
        printf("index 参数不合法 \n");
        return;
    }

    // =================== 开始删除 ===================
    if (pos > L->len - 1) // 尾删
    {
        L->len--;
        return;
    }

    for (size_t i = pos; i < L->len; i++) // 中间删除
    {
        L->data[i - 1] = L->data[i];
    }
    /*
    条件
        i = pos = 1
        L->len = 4
        10 20 30 40
    第一次循环  条件满足 i < L->len    1  < 4
        20 20 30 40
    第二次循环  条件满足 i < L-s>len    2  < 4
        20 30 30 40
    第三次循环  条件满足 i < L-s>len    3  < 4
        20 30 40 40
    */

    L->len--;

    return;
}

// 顺序表的合并1：
void Merge_Sql_Lists1(Sql_list *L1, Sql_list *L2)
{
    // 安全判断
    if (NULL == L1 || NULL == L1)
    {
        printf("顺序表 为 NULL \n");
        return;
    }
    if (MAX_SIZ < L1->len + L2->len)
    {
        printf("顺序表 有越界的风险 \n");
        return;
    }
    if (0 == L2->len)
    {
        printf("L2 中 无数据\n");
        return;
    }
    for (size_t i = L1->len, j = 0; j < L2->len; i++, j++)
    {
        L1->data[i] = L2->data[j];
        L1->len++;
    }
}
// 顺序表的合并2：
void Merge_Sql_Lists2(Sql_list *L1, Sql_list *L2)
{
    // 安全判断
    if (NULL == L1 || NULL == L1)
    {
        printf("顺序表 为 NULL \n");
        return;
    }
    if (MAX_SIZ < L1->len + L2->len)
    {
        printf("顺序表 有越界的风险 \n");
        return;
    }
    if (0 == L2->len)
    {
        printf("L2 中 无数据\n");
        return;
    }
    for (size_t i = L1->len, j = 0; j < L2->len; i++, j++)
    {
        L1->data[i] = L2->data[j];
        L1->len++;
    }
    for (size_t i = 0; i < L2->len; i++)
    {
        tail_insert_list(L1, L2->data[i]);
    }
}
// 顺序表的合并3：
Sql_list Merge_Sql_Lists(Sql_list *L1, Sql_list *L2)
{
    Sql_list L3;
    Init_Sql_List(&L3);
    // 安全判断
    if (NULL == L1 || NULL == L1)
    {
        printf("顺序表 为 NULL \n");
        return L3;
    }
    if (MAX_SIZ < L1->len + L2->len)
    {
        printf("顺序表 有越界的风险 \n");
        return L3;
    }
    if (0 == L2->len)
    {
        printf("L2 中 无数据\n");
        return L3;
    }
    // 扩容方式3   返回值 类型为 Sql_list
    for (size_t i = 0; i < L1->len; i++)
    {
        tail_insert_list(&L3, L1->data[i]);
    }
    for (size_t i = 0; i < L2->len; i++)
    {
        tail_insert_list(&L3, L2->data[i]);
    }

    return L3;
}
